import fs from 'fs';
import path from 'path';
import chalk from 'chalk';
import { fileURLToPath } from 'url';
import { dirname } from 'path';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

// 检查配置的主函数
async function checkTypeScriptConfig() {
  console.log(chalk.blue('=== TypeScript 项目检查工具 ===\n'));

  let hasIssues = false;

  try {
    // 检查项目结构
    console.log(chalk.blue('第 1 步：检查项目结构'));
    checkProjectStructure();

    // 检查 TypeScript 配置
    console.log(chalk.blue('\n第 2 步：检查 TypeScript 配置'));
    checkTsConfig();

    // 检查 ESLint 配置
    console.log(chalk.blue('\n第 3 步：检查 ESLint 配置'));
    checkEslintConfig();

    // 检查类型声明文件
    console.log(chalk.blue('\n第 4 步：检查类型声明文件'));
    checkTypeDeclarations();

    // 检查 Vue 组件
    console.log(chalk.blue('\n第 5 步：检查 Vue 组件'));
    await checkVueComponents();

    // 检查依赖项
    console.log(chalk.blue('\n第 6 步：检查依赖项'));
    checkDependencies();

    console.log(chalk.blue('\n=== 检查完成 ===\n'));

    // 输出总结建议
    printSummary();

  } catch (error) {
    console.error(chalk.red('\n检查过程中发生错误:'), error);
    hasIssues = true;
  }

  return hasIssues;
}

// 检查项目结构
function checkProjectStructure() {
  console.log(chalk.yellow('检查项目结构:'));

  const requiredFiles = [
    'tsconfig.json',
    'tsconfig.app.json',
    'env.d.ts',
    'src/main.ts'
  ];

  requiredFiles.forEach(file => {
    const exists = fs.existsSync(path.join(process.cwd(), file));
    if (exists) {
      console.log(chalk.green(`✓ ${file} 存在`));
    } else {
      console.log(chalk.red(`✗ ${file} 不存在`));
      printSolution(`请创建 ${file} 文件。可以参考 Vue 3 + TypeScript 项目模板。`);
    }
  });
}

// 检查 TypeScript 配置
function checkTsConfig() {
  console.log(chalk.yellow('检查 TypeScript 配置:'));

  try {
    const tsconfig = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'tsconfig.json'), 'utf8'));
    const tsconfigApp = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'tsconfig.app.json'), 'utf8'));

    // 检查关键配置项
    const requiredOptions = {
      'strict': true,
      'moduleResolution': ['node', 'bundler'],
      'esModuleInterop': true,
      'skipLibCheck': true,
      'noImplicitAny': true
    };

    const config = { ...tsconfig.compilerOptions, ...tsconfigApp.compilerOptions };

    Object.entries(requiredOptions).forEach(([option, value]) => {
      if (Array.isArray(value)) {
        if (value.includes(config[option])) {
          console.log(chalk.green(`✓ ${option} 配置正确`));
        } else {
          console.log(chalk.red(`✗ ${option} 配置可能需要调整`));
          printSolution(`建议将 ${option} 设置为: ${value.join(' 或 ')}`);
        }
      } else if (config[option] === value) {
        console.log(chalk.green(`✓ ${option} 配置正确`));
      } else {
        console.log(chalk.red(`✗ ${option} 配置可能需要调整`));
        printSolution(`建议将 ${option} 设置为: ${value}`);
      }
    });
  } catch (error) {
    console.log(chalk.red('✗ 无法读取 TypeScript 配置文件'));
    printSolution('请确保 tsconfig.json 和 tsconfig.app.json 文件存在且格式正确。');
  }
}

// 检查 ESLint 配置
function checkEslintConfig() {
  console.log(chalk.yellow('检查 ESLint 配置:'));

  const packageJsonPath = path.join(process.cwd(), 'package.json');
  try {
    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
    const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
    
    // 检查必要的 ESLint 依赖
    const requiredDeps = [
      '@typescript-eslint/parser',
      '@typescript-eslint/eslint-plugin',
      '@vue/eslint-config-typescript',
      'eslint-plugin-vue'
    ];

    requiredDeps.forEach(dep => {
      if (dependencies[dep]) {
        console.log(chalk.green(`✓ 已安装 ${dep}`));
      } else {
        console.log(chalk.red(`✗ 缺少 ${dep}`));
        printSolution(`请安装 ${dep}: npm install -D ${dep}`);
      }
    });

    // 检查 ESLint 配置文件是否存在
    const eslintConfigFiles = [
      'eslint.config.ts',
      '.eslintrc.js',
      '.eslintrc.cjs',
      '.eslintrc.json'
    ];

    const hasEslintConfig = eslintConfigFiles.some(file => 
      fs.existsSync(path.join(process.cwd(), file))
    );

    if (hasEslintConfig) {
      console.log(chalk.green('✓ 存在 ESLint 配置文件'));
    } else {
      console.log(chalk.red('✗ 缺少 ESLint 配置文件'));
      printSolution('请创建 ESLint 配置文件并添加 TypeScript 相关规则。');
    }

    // 检查 VSCode 集成
    const vscodePath = path.join(process.cwd(), '.vscode');
    const settingsPath = path.join(vscodePath, 'settings.json');
    
    if (fs.existsSync(settingsPath)) {
      const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
      if (settings['eslint.validate']?.includes('typescript')) {
        console.log(chalk.green('✓ VSCode ESLint TypeScript 验证已配置'));
      } else {
        console.log(chalk.yellow('! 建议配置 VSCode ESLint TypeScript 验证'));
        printSolution('在 .vscode/settings.json 中添加 TypeScript 验证配置。');
      }
    }
  } catch (error) {
    console.log(chalk.red('✗ 检查 ESLint 配置时发生错误'));
    printSolution('请确保相关配置文件格式正确。');
  }
}

// 检查类型声明文件
function checkTypeDeclarations() {
  console.log(chalk.yellow('检查类型声明文件:'));

  const envDtsPath = path.join(process.cwd(), 'env.d.ts');
  try {
    const envDtsContent = fs.readFileSync(envDtsPath, 'utf8');

    // 检查是否包含必要的类型声明
    const checks = {
      'Vue 组件声明': envDtsContent.includes('.vue'),
      '环境变量声明': envDtsContent.includes('ImportMetaEnv'),
    };

    Object.entries(checks).forEach(([name, exists]) => {
      if (exists) {
        console.log(chalk.green(`✓ ${name}已定义`));
      } else {
        console.log(chalk.red(`✗ 缺少${name}`));
        printSolution(`请在 env.d.ts 中添加${name}。`);
      }
    });
  } catch (error) {
    console.log(chalk.red('✗ 无法读取 env.d.ts 文件'));
    printSolution('请确保 env.d.ts 文件存在且包含必要的类型声明。');
  }
}

// 检查 Vue 组件
async function checkVueComponents() {
  console.log(chalk.yellow('检查 Vue 组件 TypeScript 使用情况:'));

  const srcPath = path.join(process.cwd(), 'src');
  try {
    const vueFiles = findVueFiles(srcPath);
    let hasIssues = false;

    for (const file of vueFiles) {
      const content = fs.readFileSync(file, 'utf8');
      
      // 检查是否使用 lang="ts"
      if (!content.includes('lang="ts"')) {
        console.log(chalk.red(`✗ ${path.relative(process.cwd(), file)} 未使用 TypeScript`));
        hasIssues = true;
      }

      // 检查是否定义了 Props 类型
      if (content.includes('defineProps(') && !content.includes('defineProps<')) {
        console.log(chalk.yellow(`! ${path.relative(process.cwd(), file)} Props 可能缺少类型定义`));
        hasIssues = true;
      }

      // 检查是否定义了 Emits 类型
      if (content.includes('defineEmits(') && !content.includes('defineEmits<')) {
        console.log(chalk.yellow(`! ${path.relative(process.cwd(), file)} Emits 可能缺少类型定义`));
        hasIssues = true;
      }
    }

    if (!hasIssues) {
      console.log(chalk.green('✓ 所有 Vue 组件都正确使用了 TypeScript'));
    }
  } catch (error) {
    console.log(chalk.red('✗ 检查 Vue 组件时发生错误'));
    console.error(error);
  }
}

// 检查依赖项
function checkDependencies() {
  const packageJsonPath = path.join(process.cwd(), 'package.json');
  try {
    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
    const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };

    const requiredDeps = {
      'typescript': '建议版本 >=4.5.0',
      'vue-tsc': '用于 Vue 文件类型检查',
      '@types/node': '用于 Node.js 类型支持',
      '@vue/tsconfig': 'Vue 3 TypeScript 配置'
    };

    Object.entries(requiredDeps).forEach(([dep, description]) => {
      if (dependencies[dep]) {
        console.log(chalk.green(`✓ ${dep} 已安装 (${dependencies[dep]})`));
      } else {
        console.log(chalk.red(`✗ 缺少 ${dep} - ${description}`));
        printSolution(`安装命令: npm install -D ${dep}`);
      }
    });
  } catch (error) {
    console.log(chalk.red('✗ 无法读取 package.json'));
    printSolution('请确保 package.json 文件存在且格式正确。');
  }
}

// 打印总结建议
function printSummary() {
  console.log(chalk.yellow('\n=== 改进建议 ===\n'));
  console.log('1. 类型检查:');
  console.log('   运行 `vue-tsc --noEmit` 检查全项目类型错误');
  
  console.log('\n2. 开发工具:');
  console.log('   - 安装 VS Code 的 Volar 插件获得更好的 TypeScript 支持');
  console.log('   - 在 VS Code 中启用 "Take Over Mode" 以获得最佳 TypeScript 支持');
  
  console.log('\n3. 代码质量:');
  console.log('   - 使用 `npm run lint` 检查代码规范');
  console.log('   - 考虑添加 pre-commit 钩子进行类型检查');
  
  console.log('\n4. 最佳实践:');
  console.log('   - 为所有组件的 props 和 emits 添加类型定义');
  console.log('   - 避免使用 any 类型');
  console.log('   - 利用 TypeScript 的类型推断减少冗余类型注解');
  
  console.log('\n5. 文档:');
  console.log('   查看项目中的 TypeScript 指南文档:');
  console.log('   - docs/typescript-guide.md');
  console.log('   - docs/typescript-exercises.md');
  console.log('   - docs/user-list-component.md');
}

// 辅助函数：递归查找 Vue 文件
function findVueFiles(dir) {
  let results = [];
  const files = fs.readdirSync(dir);

  for (const file of files) {
    const filePath = path.join(dir, file);
    const stat = fs.statSync(filePath);

    if (stat.isDirectory()) {
      results = results.concat(findVueFiles(filePath));
    } else if (file.endsWith('.vue')) {
      results.push(filePath);
    }
  }

  return results;
}

// 打印解决方案
function printSolution(solution) {
  console.log(chalk.gray(`  解决方案: ${solution}`));
}

// 运行检查
const hasIssues = await checkTypeScriptConfig();
process.exit(hasIssues ? 1 : 0);